<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>




<div id="article_content" class="article_content clearfix csdn-tracking-statistics" data-pid="blog" data-mod="popu_307" data-dsm="post">
    <div class="article-copyright">
        （转载）：如果文章有错误，欢迎评论或私信指出，谢谢~					https://blog.csdn.net/Yano_nankai/article/details/50957578				</div>
    <div class="markdown_views">
        <p>本文固定链接：<a href="https://www.zybuluo.com/Yano/note/321063" rel="nofollow" target="_blank">https://www.zybuluo.com/Yano/note/321063</a> <br>
            本文 PDF 下载：<a href="http://download.csdn.net/detail/yano_nankai/9469648" rel="nofollow" target="_blank">http://download.csdn.net/detail/yano_nankai/9469648</a> <br>


            <a href="http://blog.csdn.net/yano_nankai" target="_blank">http://blog.csdn.net/yano_nankai</a></p><p data-anchor-id="gv44">周志明著的《深入理解 Java 虚拟机》的干货~如有错误，欢迎指出 O(∩_∩)O 转载请保留以上信息。</p><hr><p data-anchor-id="sav2"><div class="toc"><div class="toc">
        <ul>
            <li><a href="#java-虚拟机面试题全面解析">Java 虚拟机面试题全面解析</a></li>
            <li><a href="#jdk-是什么">JDK 是什么？</a></li>
            <li><a href="#jre-是什么">JRE 是什么？</a></li>
            <li><a href="#java历史版本的特性">Java历史版本的特性？</a><ul>
                <li><ul>
                    <li><a href="#java-version-se-50">Java Version SE 5.0</a></li>
                    <li><a href="#java-version-se-6">Java Version SE 6</a></li>
                    <li><a href="#java-version-se-7">Java Version SE 7</a></li>
                    <li><a href="#java-8">Java 8</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#运行时数据区域包括哪些">运行时数据区域包括哪些？</a><ul>
                <li><ul>
                    <li><a href="#程序计数器线程私有">程序计数器（线程私有）</a></li>
                    <li><a href="#java-虚拟机栈线程私有">Java 虚拟机栈（线程私有）</a></li>
                    <li><a href="#本地方法栈线程私有">本地方法栈（线程私有）</a></li>
                    <li><a href="#java-堆线程共享">Java 堆（线程共享）</a></li>
                    <li><a href="#方法区线程共享">方法区（线程共享）</a></li>
                    <li><a href="#运行时常量池">运行时常量池</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#java-中对象访问是如何进行的">Java 中对象访问是如何进行的？</a></li>
            <li><a href="#如何判断对象是否死去">如何判断对象是否“死去”？</a><ul>
                <li><a href="#什么是引用计数法">什么是引用计数法？</a><ul>
                    <li><a href="#引用计数法的缺点">引用计数法的缺点？</a></li>
                </ul>
                </li>
                <li><a href="#什么是根搜索算法">什么是根搜索算法？</a></li>
            </ul>
            </li>
            <li><a href="#java-的4种引用方式">Java 的4种引用方式？</a><ul>
                <li><ul>
                    <li><a href="#强引用">强引用</a></li>
                    <li><a href="#软引用">软引用</a></li>
                    <li><a href="#弱引用">弱引用</a></li>
                    <li><a href="#虚引用">虚引用</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#有哪些垃圾收集算法">有哪些垃圾收集算法？</a><ul>
                <li><a href="#标记-清除算法mark-sweep">标记-清除算法（Mark-Sweep）</a><ul>
                    <li><a href="#什么是标记-清除算法">什么是标记-清除算法？</a></li>
                    <li><a href="#有什么缺点">有什么缺点？</a></li>
                </ul>
                </li>
                <li><a href="#复制算法copying-新生代">复制算法（Copying）-&nbsp;新生代</a><ul>
                    <li><a href="#优点">优点？</a></li>
                    <li><a href="#缺点">缺点？</a></li>
                    <li><a href="#应用">应用？</a></li>
                </ul>
                </li>
                <li><a href="#标记-整理算法mark-compact-老年代">标记-整理算法（Mark-Compact）-老年代</a></li>
                <li><a href="#分代收集算法">分代收集算法</a></li>
            </ul>
            </li>
            <li><a href="#minor-gc-和-full-gc有什么区别">Minor GC 和 Full GC有什么区别？</a></li>
            <li><a href="#java-内存">Java 内存</a><ul>
                <li><a href="#为什么要将堆内存分区">为什么要将堆内存分区？</a></li>
                <li><a href="#堆内存分为哪几块">堆内存分为哪几块？</a></li>
                <li><a href="#分代收集算法-1">分代收集算法</a><ul>
                    <li><a href="#内存分配有哪些原则">内存分配有哪些原则？</a></li>
                    <li><a href="#young-generation-space-采用复制算法">Young Generation Space （采用复制算法）</a></li>
                    <li><a href="#tenure-generation-space采用标记-整理算法">Tenure Generation Space（采用标记-整理算法）</a></li>
                    <li><a href="#permanent-space">Permanent Space</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#class文件">Class文件</a><ul>
                <li><ul>
                    <li><a href="#java虚拟机的平台无关性">Java虚拟机的平台无关性</a></li>
                    <li><a href="#class文件的组成">Class文件的组成？</a></li>
                    <li><a href="#魔数与class文件的版本">魔数与Class文件的版本</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#类加载器">类加载器</a><ul>
                <li><ul>
                    <li><a href="#类加载器的作用是什么">类加载器的作用是什么？</a></li>
                    <li><a href="#类加载器有哪些">类加载器有哪些？</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#类加载机制">类加载机制</a><ul>
                <li><ul>
                    <li><a href="#什么是双亲委派模型">什么是双亲委派模型？</a></li>
                    <li><a href="#为什么要使用双亲委派模型组织类加载器之间的关系">为什么要使用双亲委派模型，组织类加载器之间的关系？</a></li>
                    <li><a href="#什么是类加载机制">什么是类加载机制？</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#虚拟机和物理机的区别是什么">虚拟机和物理机的区别是什么？</a></li>
            <li><a href="#运行时栈帧结构">运行时栈帧结构</a></li>
            <li><a href="#java-方法调用">Java 方法调用</a><ul>
                <li><ul>
                    <li><a href="#什么是方法调用">什么是方法调用？</a></li>
                    <li><a href="#java的方法调用有什么特殊之处">Java的方法调用，有什么特殊之处？</a></li>
                    <li><a href="#java虚拟机调用字节码指令有哪些">Java虚拟机调用字节码指令有哪些？</a></li>
                    <li><a href="#虚拟机是如何执行方法里面的字节码指令的">虚拟机是如何执行方法里面的字节码指令的？</a></li>
                    <li><a href="#解释执行">解释执行</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#基于栈的指令集和基于寄存器的指令集">基于栈的指令集和基于寄存器的指令集</a><ul>
                <li><ul>
                    <li><a href="#什么是基于栈的指令集">什么是基于栈的指令集？</a></li>
                    <li><a href="#什么是基于寄存器的指令集">什么是基于寄存器的指令集？</a></li>
                    <li><a href="#基于栈的指令集的优缺点">基于栈的指令集的优缺点？</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#javac编译过程分为哪些步骤">Javac编译过程分为哪些步骤？</a></li>
            <li><a href="#什么是即时编译器">什么是即时编译器？</a></li>
            <li><a href="#解释器和编译器">解释器和编译器</a><ul>
                <li><ul>
                    <li><a href="#为什么要采用分层编译">为什么要采用分层编译？</a></li>
                    <li><a href="#分层编译器有哪些层次">分层编译器有哪些层次？</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#编译对象与触发条件">编译对象与触发条件</a><ul>
                <li><ul>
                    <li><a href="#热点代码有哪些">热点代码有哪些？</a></li>
                    <li><a href="#如何判断一段代码是不是热点代码">如何判断一段代码是不是热点代码？</a></li>
                    <li><a href="#hotspot虚拟机使用第二种有两个计数器">HotSpot虚拟机使用第二种，有两个计数器：</a></li>
                    <li><a href="#方法调用计数器统计方法">方法调用计数器统计方法</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#有哪些经典的优化技术即时编译器">有哪些经典的优化技术（即时编译器）？</a><ul>
                <li><ul>
                    <li><a href="#公共子表达式消除">公共子表达式消除</a></li>
                    <li><a href="#数组边界检查消除">数组边界检查消除</a></li>
                    <li><a href="#方法内联">方法内联</a></li>
                    <li><a href="#逃逸分析">逃逸分析</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#如果对象不会逃逸到方法或线程外可以做什么优化">如果对象不会逃逸到方法或线程外，可以做什么优化？</a></li>
            <li><a href="#java与cc的编译器对比">Java与C/C++的编译器对比</a></li>
            <li><a href="#物理机如何处理并发问题">物理机如何处理并发问题？</a></li>
            <li><a href="#java-内存模型">Java 内存模型</a><ul>
                <li><a href="#什么是java内存模型">什么是Java内存模型？</a></li>
                <li><a href="#java内存模型的目标">Java内存模型的目标？</a><ul>
                    <li><a href="#主内存与工作内存">主内存与工作内存</a></li>
                    <li><a href="#内存间的交互操作">内存间的交互操作</a></li>
                    <li><a href="#原子性可见性有序性">原子性、可见性、有序性</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#volatile">volatile</a><ul>
                <li><ul>
                    <li><a href="#什么是volatile">什么是volatile？</a></li>
                    <li><a href="#为什么基于volatile变量的运算在并发下不一定是安全的">为什么基于volatile变量的运算在并发下不一定是安全的？</a></li>
                    <li><a href="#为什么使用volatile">为什么使用volatile？</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#并发与线程">并发与线程</a><ul>
                <li><ul>
                    <li><a href="#并发与线程的关系">并发与线程的关系？</a></li>
                    <li><a href="#什么是线程">什么是线程？</a></li>
                    <li><a href="#实现线程有哪些方式">实现线程有哪些方式？</a></li>
                    <li><a href="#java线程的实现">Java线程的实现</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#java线程调度">Java线程调度</a><ul>
                <li><ul>
                    <li><a href="#什么是线程调度">什么是线程调度？</a></li>
                    <li><a href="#线程调度有哪些方法">线程调度有哪些方法？</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#线程安全的定义">线程安全的定义？</a></li>
            <li><a href="#java语言操作的共享数据包括哪些">Java语言操作的共享数据，包括哪些？</a><ul>
                <li><ul>
                    <li><a href="#不可变">不可变</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#如何实现线程安全">如何实现线程安全？</a><ul>
                <li><ul>
                    <li><a href="#阻塞同步互斥同步">阻塞同步（互斥同步）</a></li>
                    <li><a href="#非阻塞同步">非阻塞同步</a></li>
                </ul>
                </li>
            </ul>
            </li>
            <li><a href="#锁优化是在jdk的那个版本">锁优化是在JDK的那个版本？</a><ul>
                <li><ul>
                    <li><a href="#为什么要提出自旋锁">为什么要提出自旋锁？</a></li>
                    <li><a href="#自旋锁的原理">自旋锁的原理？</a></li>
                    <li><a href="#自旋的缺点">自旋的缺点？</a></li>
                    <li><a href="#什么是自适应自旋">什么是自适应自旋？</a></li>
                    <li><a href="#锁消除">锁消除</a></li>
                    <li><a href="#锁粗化">锁粗化</a></li>
                    <li><a href="#轻量级锁">轻量级锁</a></li>
                    <li><a href="#偏向锁">偏向锁</a></li>
                </ul>
                </li>
            </ul>
            </li>
        </ul>
    </div>
    </div>
        </p><div class="md-section-divider"></div><h1 data-anchor-id="r1q2" id="jdk-是什么">JDK 是什么？</h1><p data-anchor-id="0tpp">JDK 是用于支持 Java 程序<font color="#ff0000">开发</font>的最小环境。</p><ol data-anchor-id="avx0">
        <li><p>Java 程序设计语言</p></li>
        <li><p>Java 虚拟机</p></li>
        <li><p>Java API类库</p></li>
    </ol><div class="md-section-divider"></div><h1 data-anchor-id="zp5r" id="jre-是什么">JRE 是什么？</h1><p data-anchor-id="ase6">JRE 是支持 Java 程序<font color="#ff0000">运行</font>的标准环境。</p><ol data-anchor-id="bjmd">
        <li><p>Java SE API 子集</p></li>
        <li><p>Java 虚拟机</p></li>
    </ol><div class="md-section-divider"></div><h1 data-anchor-id="08sl" id="java历史版本的特性">Java历史版本的特性？</h1><div class="md-section-divider"></div><h3 data-anchor-id="v7ny" id="java-version-se-50">Java Version SE 5.0</h3><ul data-anchor-id="9w72">
        <li>引入<font color="#ff0000">泛型</font>；</li>
        <li>增强循环，可以使用迭代方式；</li>
        <li><font color="#ff0000">自动装箱与自动拆箱</font>；</li>
        <li>类型安全的<font color="#ff0000">枚举</font>；</li>
        <li><font color="#ff0000">可变参数</font>；</li>
        <li>静态引入；</li>
        <li>元数据（注解）；</li>
        <li>引入Instrumentation。</li>
    </ul><p></p><div class="md-section-divider"></div><h3 data-anchor-id="lgeg" id="java-version-se-6">Java Version SE 6</h3><ul data-anchor-id="785l">
        <li>支持<font color="#ff0000">脚本语言</font>；</li>
        <li>引入JDBC 4.0 API；</li>
        <li>引入Java Compiler API；</li>
        <li>可插拔注解；</li>
        <li>增加对Native PKI(Public Key Infrastructure)、Java GSS(Generic Security Service)、Kerberos和LDAP(Lightweight Directory Access Protocol)的支持；</li>
        <li>继承Web Services；</li>
        <li>做了很多优化。</li>
    </ul><div class="md-section-divider"></div><h3 data-anchor-id="h73q" id="java-version-se-7">Java Version SE 7</h3><ul data-anchor-id="6o90">
        <li><font color="#ff0000">switch语句块</font>中允许以<font color="#ff0000">字符串</font>作为分支条件；</li>
        <li>在创建泛型对象时应用类型推断；</li>
        <li>在一个语句块中捕获多种异常；</li>
        <li>支持动态语言；</li>
        <li>支持<font color="#ff0000">try-with-resources</font>；</li>
        <li>引入Java NIO.2开发包；</li>
        <li>数值类型可以用2进制字符串表示，并且可以在字符串表示中添加下划线；</li>
        <li>钻石型语法；</li>
        <li><font color="#ff0000">null值</font>的自动处理。</li>
    </ul><div class="md-section-divider"></div><h3 data-anchor-id="k0k6" id="java-8">Java 8</h3><ul data-anchor-id="98ic">
        <li><font color="#ff0000">函数式接口</font></li>
        <li><font color="#ff0000">Lambda表达式</font></li>
        <li>接口的增强</li>
    </ul><div class="md-section-divider"></div><h1 data-anchor-id="3vd8" id="运行时数据区域包括哪些">运行时数据区域包括哪些？</h1><ol data-anchor-id="qz4a">
        <li><p>程序计数器</p></li>
        <li><p>Java 虚拟机栈</p></li>
        <li><p>本地方法栈</p></li>
        <li><p>Java 堆</p></li>
        <li><p>方法区</p></li>
        <li><p>运行时常量池</p></li>
        <li><p>直接内存</p></li>
    </ol><div class="md-section-divider"></div><h3 data-anchor-id="od1k" id="程序计数器线程私有">程序计数器（线程私有）</h3><p data-anchor-id="g7n5">程序计数器（Program Counter Register）是一块<font color="#ff0000">较小的内存空间</font>，可以看作是当前线程所执行字节码的<font color="#ff0000">行号指示器</font>。分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器完成。</p><p data-anchor-id="hxd2">由于 Java 虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式实现的。为了线程切换后能恢复到正确的执行位置，每条线程都需要一个<font color="#ff0000">独立的程序计数器</font>，各线程之间的计数器互不影响，独立存储。</p><ol data-anchor-id="8aba">
        <li><p>如果线程正在执行的是一个 Java 方法，计数器记录的是正在执行的虚拟机字节码指令的地址；</p></li>
        <li><p>如果正在执行的是 Native 方法，这个计数器的值为空。</p></li>
    </ol><p data-anchor-id="bx2v">程序计数器是唯一一个没有规定任何 OutOfMemoryError 的区域。</p><div class="md-section-divider"></div><h3 data-anchor-id="yjee" id="java-虚拟机栈线程私有">Java 虚拟机栈（线程私有）</h3><p data-anchor-id="0oho">Java 虚拟机栈（Java Virtual Machine Stacks）是<font color="#ff0000">线程私有</font>的，生命周期与线程相同。 <br>
        虚拟机栈描述的是&nbsp;<font color="#ff0000">Java 方法执行的内存模型</font>：每个方法被执行的时候都会创建一个<font color="#ff0000">栈帧</font>（Stack Frame），存储</p><ol data-anchor-id="hts9">
        <li><p>局部变量表</p></li>
        <li><p>操作栈</p></li>
        <li><p>动态链接</p></li>
        <li><p>方法出口</p></li>
    </ol><p data-anchor-id="30iz">每一个方法被调用到执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。</p><p data-anchor-id="ub7l">这个区域有两种异常情况：</p><ol data-anchor-id="mrft">
        <li><p>StackOverflowError：线程请求的栈深度大于虚拟机所允许的深度</p></li>
        <li><p>OutOfMemoryError：虚拟机栈扩展到无法申请足够的内存时</p></li>
    </ol><div class="md-section-divider"></div><h3 data-anchor-id="08ue" id="本地方法栈线程私有">本地方法栈（线程私有）</h3><p data-anchor-id="jr4j">虚拟机栈为虚拟机执行 Java 方法（字节码）服务。</p><p data-anchor-id="kjct">本地方法栈（Native Method Stacks）为虚拟机使用到的 Native 方法服务。</p><div class="md-section-divider"></div><h3 data-anchor-id="a2bj" id="java-堆线程共享">Java 堆（线程共享）</h3><p data-anchor-id="ixns">Java 堆（Java Heap）是 Java 虚拟机中<font color="#ff0000">内存最大</font>的一块。Java 堆在虚拟机启动时创建，被所有线程共享。</p><p data-anchor-id="nu2g">作用：<font color="#ff0000">存放对象实例</font>。垃圾收集器主要管理的就是 Java 堆。Java 堆<font color="#ff0000">在物理上可以不连续</font>，只要逻辑上连续即可。</p><div class="md-section-divider"></div><h3 data-anchor-id="crg4" id="方法区线程共享">方法区（线程共享）</h3><p data-anchor-id="mzi6">方法区（Method Area）被所有线程共享，用于存储<font color="#ff0000">已被虚拟机加载</font>的<font color="#ff0000">类信息、常量、静态变量、即时编译器编译后的代码</font>等数据。</p><p data-anchor-id="7las">和 Java 堆一样，<font color="#ff0000">不需要连续的内存</font>，可以选择固定的大小，更可以选择不实现垃圾收集。</p><div class="md-section-divider"></div><h3 data-anchor-id="3qj5" id="运行时常量池">运行时常量池</h3><p data-anchor-id="v7zh">运行时常量池（Runtime Constant Pool）是方法区的一部分。保存 Class 文件中的符号引用、翻译出来的直接引用。运行时常量池可以在运行期间将新的常量放入池中。</p><div class="md-section-divider"></div><h1 data-anchor-id="5uac" id="java-中对象访问是如何进行的">Java 中对象访问是如何进行的？</h1><pre data-anchor-id="qf74"><code>Object obj =  new  Object();
</code></pre><p data-anchor-id="bj8t">对于上述最简单的访问，也会涉及到 Java 栈、Java 堆、方法区这三个最重要内存区域。</p><pre data-anchor-id="cwgp"><code>Object obj
</code></pre><p data-anchor-id="hq6h">如果出现在方法体中，则上述代码会反映到 Java 栈的本地变量表中，作为 reference 类型数据出现。</p><pre data-anchor-id="idkp"><code>new  Object()
</code></pre><p data-anchor-id="y7nt">反映到 Java 堆中，形成一块存储了 Object 类型所有<font color="#ff0000">对象实例数据</font>值的内存。Java堆中还包含<font color="#ff0000">对象类型数据</font>的地址信息，这些类型数据存储在方法区中。</p><div class="md-section-divider"></div><h1 data-anchor-id="twt1" id="如何判断对象是否死去">如何判断对象是否“死去”？</h1><ol data-anchor-id="l1d3">
        <li><p><font color="#ff0000">引用计数法</font></p></li>
        <li><p><font color="#ff0000">根搜索算法</font></p></li>
    </ol><div class="md-section-divider"></div><h2 data-anchor-id="qw2a" id="什么是引用计数法">什么是引用计数法？</h2><p data-anchor-id="acvf">给对象添加一个引用计数器，每当有一个地方引用它，计数器就+1,；当引用失效时，计数器就-1；任何时刻计数器都为0的对象就是不能再被使用的。</p><div class="md-section-divider"></div><h3 data-anchor-id="38ny" id="引用计数法的缺点">引用计数法的缺点？</h3><p data-anchor-id="22mm">很难解决对象之间的<font color="#ff0000">循环引用</font>问题。</p><div class="md-section-divider"></div><h2 data-anchor-id="6u8s" id="什么是根搜索算法">什么是根搜索算法？</h2><p data-anchor-id="4ya5">通过一系列的名为“<font color="#ff0000">GC Roots</font>”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为<font color="#ff0000">引用链</font>（Reference Chain），当一个对象到 GC Roots 没有任何引用链相连（用图论的话来说就是从 GC Roots 到这个对象不可达）时，则证明此对象是不可用的。</p><p data-anchor-id="wh20"><img src="http://static.zybuluo.com/Yano/bgl07z2uk1qdwirwoy0rrrj7/1.jpg" alt="1.jpg-40.4kB" title=""></p><div class="md-section-divider"></div><h1 data-anchor-id="tk7r" id="java-的4种引用方式">Java 的4种引用方式？</h1><p data-anchor-id="uko5">在 JDK 1.2 之后，Java 对引用的概念进行了扩充，将引用分为</p><ol data-anchor-id="39o6">
        <li><p>强引用 Strong Reference</p></li>
        <li><p>软引用 Soft Reference</p></li>
        <li><p>弱引用 Weak Reference</p></li>
        <li><p>虚引用 Phantom Reference</p></li>
    </ol><div class="md-section-divider"></div><h3 data-anchor-id="7ilv" id="强引用">强引用</h3><pre data-anchor-id="0ayj"><code>Object obj =  new  Object();
</code></pre><p data-anchor-id="vd1a">代码中普遍存在的，像上述的引用。只要强引用还在，垃圾收集器永远不会回收掉被引用的对象。</p><div class="md-section-divider"></div><h3 data-anchor-id="3sdu" id="软引用">软引用</h3><p data-anchor-id="kden">用来描述一些<font color="#ff0000">还有用，但并非必须</font>的对象。软引用所关联的对象，有在系统将要<font color="#ff0000">发生内存溢出异常之前</font>，将会把这些对象列进回收范围，并进行<font color="#ff0000">第二次回收</font>。如果这次回收还是没有足够的内存，才会抛出内存异常。提供了&nbsp;<font color="#ff0000">SoftReference&nbsp;</font>类实现软引用。</p><div class="md-section-divider"></div><h3 data-anchor-id="4eex" id="弱引用">弱引用</h3><p data-anchor-id="tryw">描述非必须的对象，强度比软引用更弱一些，被弱引用关联的对象，只能<font color="#ff0000">生存到下一次垃圾收集发生前</font>。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。提供了 WeakReference 类来实现弱引用。</p><div class="md-section-divider"></div><h3 data-anchor-id="gsi0" id="虚引用">虚引用</h3><p data-anchor-id="11pd">一个对象是否有虚引用，完全不会对其生存时间够成影响，也无法通过虚引用来取得一个对象实例。为一个对象关联虚引用的唯一目的，就是希望在<font color="#ff0000">这个对象被收集器回收时</font>，收到一个<font color="#ff0000">系统通知</font>。提供了 PhantomReference 类来实现虚引用。</p><div class="md-section-divider"></div><h1 data-anchor-id="iyrh" id="有哪些垃圾收集算法">有哪些垃圾收集算法？</h1><ol data-anchor-id="y2hf">
        <li><p><font color="#ff0000">标记-清除算法</font></p></li>
        <li><p><font color="#ff0000">复制算法 <br>
        </font></p></li>
        <li><p><font color="#ff0000">标记-整理算法 <br>
        </font></p></li>
        <li><p><font color="#ff0000">分代收集算法</font></p></li>
    </ol><div class="md-section-divider"></div><h2 data-anchor-id="u7rs" id="标记-清除算法mark-sweep">标记-清除算法（Mark-Sweep）</h2><div class="md-section-divider"></div><h3 data-anchor-id="v1y1" id="什么是标记-清除算法">什么是标记-清除算法？</h3><p data-anchor-id="huch">分为<font color="#ff0000">标记</font>和<font color="#ff0000">清除</font>两个阶段。首先标记出所有需要回收的对象，在标记完成后统一回收被标记的对象。</p><div class="md-section-divider"></div><h3 data-anchor-id="owdk" id="有什么缺点">有什么缺点？</h3><p data-anchor-id="40w4">1. 效率问题。标记和清除过程的效率都不高。 <br>
        2. 空间问题。标记清除之后会产生大量<font color="#ff0000">不连续的内存碎片</font>，空间碎片太多可能导致，程序<font color="#ff0000">分配较大对象时</font>无法找到足够的连续内存，不得不提前出发另一次垃圾收集动作。</p><p data-anchor-id="kgd7"><img src="http://static.zybuluo.com/Yano/yx9r4uty6h69bsmdv7tqxq9o/2.jpg" alt="2.jpg-81.6kB" title=""></p><div class="md-section-divider"></div><h2 data-anchor-id="rncc" id="复制算法copying-新生代"><font color="#ff0000">复制</font>算法（Copying）-&nbsp;<font color="#ff0000">新生代</font></h2><p data-anchor-id="jkhc">将可用内存按容量划分为大小相等的两块，每次只使用其中一块。当这一块的内存用完了，就<font color="#ff0000">将存活着的对象复制到另一块上面</font>，然后再把已经使用过的内存空间一次清理掉。</p><div class="md-section-divider"></div><h3 data-anchor-id="xna8" id="优点">优点？</h3><p data-anchor-id="v2sg">复制算法使得每次都是针对其中的一块进行内存回收，内存分配时也<font color="#ff0000">不用考虑内存碎片</font>等复杂情况，只要移动堆顶指针，按顺序分配内存即可，实现简单，运行高效。</p><div class="md-section-divider"></div><h3 data-anchor-id="6jbp" id="缺点">缺点？</h3><p data-anchor-id="b146">将内存缩小为原来的一半。在<font color="#ff0000">对象存活率较高时</font>，需要执行<font color="#ff0000">较多的复制操作</font>，效率会变低。</p><p data-anchor-id="dv14"><img src="http://static.zybuluo.com/Yano/b7gljelr9w4zwfx9xic1m90m/3.jpg" alt="3.jpg-95.7kB" title=""></p><div class="md-section-divider"></div><h3 data-anchor-id="itrf" id="应用">应用？</h3><p data-anchor-id="glgu">商业的虚拟机都采用复制算法来<font color="#ff0000">回收新生代</font>。因为新生代中的对象容易死亡，所以并不需要按照1:1的比例划分内存空间，而是将内存分为<font color="#ff0000">一块较大的 Eden 空间</font>和<font color="#ff0000">两块较小的 Survivor 空间</font>。每次使用 Eden 和其中的一块 Survivor。</p><p data-anchor-id="jy5y">当回收时，将 Eden 和 Survivor 中还存活的对象一次性拷贝到另外一块 Survivor 空间上，最后清理掉 Eden 和刚才用过的 Survivor 空间。Hotspot 虚拟机默认 Eden 和 Survivor 的大小比例是<font color="#ff0000">8:1</font>，也就是每次新生代中可用内存空间为整个新生代容量的90%（80% + 10%），只有10%的内存是会被“浪费”的。</p><div class="md-section-divider"></div><h2 data-anchor-id="fe0c" id="标记-整理算法mark-compact-老年代">标记-整理算法（Mark-Compact）-老年代</h2><p data-anchor-id="kice">标记过程仍然与“标记-清除”算法一样，但不是直接对可回收对象进行清理，而是<font color="#ff0000">让所有存活的对象向一端移动，然后直接清理掉边界以外的内存</font>。</p><p data-anchor-id="bbgp"><img src="http://static.zybuluo.com/Yano/ykokv3ov9vxyiuntfv3d3i18/4.jpg" alt="" title=""></p><div class="md-section-divider"></div><h2 data-anchor-id="ww80" id="分代收集算法">分代收集算法</h2><p data-anchor-id="bmde">根据对象的存活周期，将内存划分为几块。一般是把<font color="#ff0000">&nbsp;Java 堆</font>分为<font color="#ff0000">新生代</font>和<font color="#ff0000">老年代</font>，这样就可以根据各个年代的特点，采用最适当的收集算法。</p><ul data-anchor-id="v8as">
        <li><p><font color="#ff0000">新生代</font>：每次垃圾收集时会有大批对象死去，只有少量存活，所以选择<font color="#ff0000">复制算法</font>，只需要少量存活对象的复制成本就可以完成收集。</p></li>
        <li><p><font color="#ff0000">老年代</font>：对象存活率高、没有额外空间对它进行分配担保，必须使用“<font color="#ff0000">标记-清理</font>”或“<font color="#ff0000">标记-整理</font>”算法进行回收。</p></li>
    </ul><div class="md-section-divider"></div><h1 data-anchor-id="mexp" id="minor-gc-和-full-gc有什么区别">Minor GC 和 Full GC有什么区别？</h1><p data-anchor-id="jted"><font color="#ff0000">Minor GC</font>：新生代 GC，指发生在新生代的垃圾收集动作，因为 Java 对象大多死亡频繁，所以 Minor GC 非常频繁，一般回收速度较快。 <br>
        <font color="#ff0000">Full GC</font>：老年代 GC，也叫 Major GC，速度一般比 Minor GC&nbsp;<font color="#ff0000">慢</font>&nbsp;10 倍以上。</p><div class="md-section-divider"></div><h1 data-anchor-id="y2oh" id="java-内存">Java 内存</h1><div class="md-section-divider"></div><h2 data-anchor-id="hcas" id="为什么要将堆内存分区">为什么要将堆内存分区？</h2><p data-anchor-id="izmz">对于一个大型的系统，当创建的对象及方法变量比较多时，即堆内存中的对象比较多，如果逐一分析对象是否该回收，效率很低。分区是为了进行<font color="#ff0000">模块化管理</font>，管理不同的对象及变量，以提高 JVM 的执行效率。</p><div class="md-section-divider"></div><h2 data-anchor-id="1wjg" id="堆内存分为哪几块">堆内存分为哪几块？</h2><ol data-anchor-id="sswu">
        <li><p>Young Generation Space 新生区（也称新生代）</p></li>
        <li><p>Tenure Generation Space养老区（也称旧生代）</p></li>
        <li><p>Permanent Space 永久存储区</p></li>
    </ol><div class="md-section-divider"></div><h2 data-anchor-id="6ogo" id="分代收集算法-1">分代收集算法</h2><div class="md-section-divider"></div><h3 data-anchor-id="l1vs" id="内存分配有哪些原则">内存分配有哪些原则？</h3><ol data-anchor-id="0kl0">
        <li><p>对象优先分配在 Eden</p></li>
        <li><p>大对象直接进入老年代</p></li>
        <li><p>长期存活的对象将进入老年代</p></li>
        <li><p>动态对象年龄判定</p></li>
        <li>空间分配担保</li>
    </ol><div class="md-section-divider"></div><h3 data-anchor-id="5vs0" id="young-generation-space-采用复制算法">Young Generation Space （采用复制算法）</h3><p data-anchor-id="5c5l">主要用来<font color="#ff0000">存储新创建的对象</font>，内存较小，垃圾回收频繁。这个区又分为三个区域：<font color="#ff0000">一个 Eden Space 和两个 Survivor Space</font>。</p><ul data-anchor-id="dkwa">
        <li><p>当对象在堆创建时，将进入年轻代的Eden Space。</p></li>
        <li><p>垃圾回收器进行垃圾回收时，扫描Eden Space和A Suvivor Space，如果对象仍然存活，则复制到B Suvivor Space，如果B Suvivor Space已经满，则复制 Old Gen</p></li>
        <li><p>扫描A Suvivor Space时，如果对象已经经过了<font color="#ff0000">几次的扫描仍然存活</font>，JVM认为其为一个Old对象，则将其<font color="#ff0000">移到Old Gen</font>。</p></li>
        <li><p>扫描完毕后，JVM将Eden Space和A Suvivor Space清空，然后交换A和B的角色（即下次垃圾回收时会扫描Eden Space和B Suvivor Space。</p></li>
    </ul><div class="md-section-divider"></div><h3 data-anchor-id="k2xw" id="tenure-generation-space采用标记-整理算法">Tenure Generation Space（采用标记-整理算法）</h3><p data-anchor-id="9hkn">主要用来<font color="#ff0000">存储长时间被引用的对象</font>。它里面存放的是经过<font color="#ff0000">几次在&nbsp;</font><font color="#ff0000">Young Generation Space 进行扫描判断过仍存活的对象</font>，内存较大，垃圾回收频率较小。</p><div class="md-section-divider"></div><h3 data-anchor-id="yqxv" id="permanent-space">Permanent Space</h3><p data-anchor-id="g6lw">存储不变的类定义、字节码和常量等。</p><div class="md-section-divider"></div><h1 data-anchor-id="7re6" id="class文件">Class文件</h1><div class="md-section-divider"></div><h3 data-anchor-id="e3m7" id="java虚拟机的平台无关性">Java虚拟机的平台无关性</h3><p data-anchor-id="ies5"><img src="http://static.zybuluo.com/Yano/a05utvf2qriox4l49kpxz249/5.jpg" alt="" title=""></p><div class="md-section-divider"></div><h3 data-anchor-id="ossn" id="class文件的组成">Class文件的组成？</h3><p data-anchor-id="yod7">Class文件是一组以<font color="#ff0000">8位字节</font>为基础单位的<font color="#ff0000">二进制流</font>，各个数据项目间没有任何分隔符。当遇到8位字节以上空间的数据项时，则会按照<font color="#ff0000">高位在前</font>的方式分隔成若干个8位字节进行存储。</p><div class="md-section-divider"></div><h3 data-anchor-id="5or9" id="魔数与class文件的版本">魔数与Class文件的版本</h3><p data-anchor-id="cm1p">每个Class文件的头4个字节称为<font color="#ff0000">魔数</font>（Magic Number），它的唯一作用是用于确定这个文件<font color="#ff0000">是否为一个能被虚拟机接受的Class文件</font>。OxCAFEBABE。</p><p data-anchor-id="ccc9">接下来是Class文件的<font color="#ff0000">版本号</font>：第5,6字节是次版本号（Minor Version），第7,8字节是主版本号（Major Version）。</p><p data-anchor-id="f99z">使用JDK 1.7编译输出Class文件，格式代码为：</p><p data-anchor-id="3ei5"><img src="http://static.zybuluo.com/Yano/6rrfu3l36nz74a8va92zjpfi/6.png" alt="" title=""></p><p data-anchor-id="pyl8">前四个字节为魔数，次版本号是0x0000，主版本号是0x0033，说明本文件是<font color="#ff0000">可以被1.7及以上版本的虚拟机执行的文件</font>。</p><ul data-anchor-id="j7pe">
        <li><p>33：JDK1.7</p></li>
        <li><p>32：JDK1.6</p></li>
        <li><p>31：JDK1.5</p></li>
        <li><p>30：JDK1.4</p></li>
        <li><p>2F：JDK1.3</p></li>
    </ul><p data-anchor-id="l4me"><img src="http://static.zybuluo.com/Yano/227jh9s6xl7wqu9xjj3s0q7s/7.jpg" alt="" title=""></p><div class="md-section-divider"></div><h1 data-anchor-id="2s2w" id="类加载器">类加载器</h1><div class="md-section-divider"></div><h3 data-anchor-id="a3zg" id="类加载器的作用是什么">类加载器的作用是什么？</h3><p data-anchor-id="1ypz">类加载器实现类的加载动作，同时用于确定一个类。对于任意一个类，都需要由<font color="#ff0000">加载它的类加载器</font>和<font color="#ff0000">这个类本身</font>一同确立其在Java虚拟机中的<font color="#ff0000">唯一性</font>。即使两个类来源于同一个Class文件，只要加载它们的类加载器不同，这两个类就不相等。</p><div class="md-section-divider"></div><h3 data-anchor-id="shaq" id="类加载器有哪些">类加载器有哪些？</h3><ol data-anchor-id="a9q6">
        <li><p><font color="#ff0000">启动类加载器</font>（Bootstrap ClassLoader）：使用C++实现（仅限于HotSpot），是虚拟机自身的一部分。负责将存放在<font color="#ff0000">\lib目录中的类库</font>加载到虚拟机中。其无法被Java程序直接引用。</p></li>
        <li><p><font color="#ff0000">扩展类加载器</font>（Extention ClassLoader）由ExtClassLoader实现，负责加载<font color="#ff0000">\lib\ext目录中的所有类库</font>，开发者可以直接使用。</p></li>
        <li><p><font color="#ff0000">应用程序类加载器</font>（Application ClassLoader）：由APPClassLoader实现。负责加载<font color="#ff0000">用户类路径（ClassPath）上所指定的类库</font>。</p></li>
    </ol><div class="md-section-divider"></div><h1 data-anchor-id="ir6i" id="类加载机制">类加载机制</h1><div class="md-section-divider"></div><h3 data-anchor-id="p12g" id="什么是双亲委派模型">什么是双亲委派模型？</h3><p data-anchor-id="3m6d">双亲委派模型（Parents Delegation Model）要求除了顶层的启动类加载器外，其余加载器都应当<font color="#ff0000">有自己的父类加载器</font>。类加载器之间的父子关系，通过<font color="#ff0000">组合</font>关系复用。 <br>
        工作过程：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求<font color="#ff0000">委派给父类加载器</font>完成。每个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到顶层的启动类加载器中，只有到父加载器反馈自己无法完成这个加载请求（它的搜索范围没有找到所需的类）时，子加载器才会尝试自己去加载。</p><div class="md-section-divider"></div><h3 data-anchor-id="stua" id="为什么要使用双亲委派模型组织类加载器之间的关系">为什么要使用双亲委派模型，组织类加载器之间的关系？</h3><p data-anchor-id="2y5h">Java类随着它的类加载器一起具备了一种带优先级的层次关系。比如java.lang.Object，它存放在rt.jar中，无论哪个类加载器要加载这个类，最终都是委派给启动类加载器进行加载，因此Object类在程序的各个类加载器环境中，都是同一个类。</p><p data-anchor-id="iu2j">如果没有使用双亲委派模型，让各个类加载器自己去加载，那么Java类型体系中最基础的行为也得不到保障，应用程序会变得一片混乱。</p><p data-anchor-id="93jr"><img src="http://static.zybuluo.com/Yano/1n7vj62xymjan72xok387nmb/8.jpg" alt="" title=""></p><div class="md-section-divider"></div><h3 data-anchor-id="xx4j" id="什么是类加载机制">什么是<font color="#ff0000">类加载机制</font>？</h3><p data-anchor-id="i6ap">Class文件描述的各种信息，都需要<font color="#ff0000">加载到虚拟机</font>后才能运行。虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的类加载机制。</p><div class="md-section-divider"></div><h1 data-anchor-id="xb3j" id="虚拟机和物理机的区别是什么">虚拟机和物理机的区别是什么？</h1><p data-anchor-id="ui70">这两种机器都有代码执行的能力，但是：</p><ul data-anchor-id="f9lt">
        <li><p><font color="#ff0000">物理机</font>的执行引擎是<font color="#ff0000">直接建立在处理器</font>、硬件、指令集和操作系统层面的。</p></li>
        <li><p><font color="#ff0000">虚拟机</font>的执行引擎是自己实现的，因此可以<font color="#ff0000">自行制定</font>指令集和执行引擎的结构体系，并且能够执行那些不被硬件直接支持的指令集格式。</p></li>
    </ul><div class="md-section-divider"></div><h1 data-anchor-id="niu2" id="运行时栈帧结构">运行时栈帧结构</h1><p data-anchor-id="rk3n"><font color="#ff0000">栈帧</font>是用于支持虚拟机进行方法调用和方法执行的数据结构， 存储了方法的</p><ul data-anchor-id="f6kf">
        <li><p>局部变量表</p></li>
        <li><p>操作数栈</p></li>
        <li><p>动态连接</p></li>
        <li><p>方法返回地址</p></li>
    </ul><p data-anchor-id="y5a4">每一个方法从调用开始到执行完成的过程，就对应着一个栈帧在虚拟机栈里面从入栈到出栈的过程。</p><p data-anchor-id="dzxe"><img src="http://static.zybuluo.com/Yano/s3zd7hp85r6365aiveq063t0/9.jpg" alt="" title=""></p><div class="md-section-divider"></div><h1 data-anchor-id="44n9" id="java-方法调用">Java 方法调用</h1><div class="md-section-divider"></div><h3 data-anchor-id="m35a" id="什么是方法调用">什么是方法调用？</h3><p data-anchor-id="aub3">方法调用唯一的任务是<font color="#ff0000">确定被调用方法的版本</font>（调用哪个方法），暂时还不涉及方法内部的具体运行过程。</p><div class="md-section-divider"></div><h3 data-anchor-id="4sge" id="java的方法调用有什么特殊之处">Java的方法调用，有什么特殊之处？</h3><p data-anchor-id="0z3v">Class文件的编译过程<font color="#ff0000">不包含</font>传统编译的<font color="#ff0000">连接步骤</font>，一切方法调用在Class文件里面存储的都只是<font color="#ff0000">符号引用</font>，而不是方法在实际运行时内存布局中的入口地址。这使得Java有强大的动态扩展能力，但使Java方法的调用过程变得相对复杂，需要在类加载期间甚至到运行时才能确定目标方法的直接引用。</p><div class="md-section-divider"></div><h3 data-anchor-id="mfc7" id="java虚拟机调用字节码指令有哪些">Java虚拟机调用字节码指令有哪些？</h3><ul data-anchor-id="v5e3">
        <li><p>invokestatic：调用静态方法</p></li>
        <li><p>invokespecial：调用实例构造器方法、私有方法和父类方法</p></li>
        <li><p>invokevirtual：调用所有的虚方法</p></li>
        <li><p>invokeinterface：调用接口方法</p></li>
    </ul><div class="md-section-divider"></div><h3 data-anchor-id="araj" id="虚拟机是如何执行方法里面的字节码指令的">虚拟机是如何<font color="#ff0000">执行方法里面的字节码指令</font>的？</h3><p data-anchor-id="ouuv"><font color="#ff0000">解释执行</font>（通过解释器执行） <br>
        <font color="#ff0000">编译执行</font>（通过即时编译器产生本地代码）</p><div class="md-section-divider"></div><h3 data-anchor-id="xdyl" id="解释执行">解释执行</h3><p data-anchor-id="u6a8">当主流的虚拟机中都包含了即时编译器后，Class文件中的代码到底会被解释执行还是编译执行，只有虚拟机自己才能准确判断。</p><p data-anchor-id="5nll">Javac编译器完成了程序代码经过词法分析、语法分析到抽象语法树，再遍历语法树生成线性的字节码指令流的过程。因为这一动作是在Java虚拟机之外进行的，而解释器在虚拟机的内部，所以Java程序的编译是半独立的实现。</p><div class="md-section-divider"></div><h1 data-anchor-id="bn1d" id="基于栈的指令集和基于寄存器的指令集">基于栈的指令集和基于寄存器的指令集</h1><div class="md-section-divider"></div><h3 data-anchor-id="glad" id="什么是基于栈的指令集">什么是基于栈的指令集？</h3><p data-anchor-id="sdup">Java编译器输出的指令流，里面的指令大部分都是零地址指令，它们依赖<font color="#ff0000">操作数栈</font>进行工作。</p><p data-anchor-id="igmi">计算“1+1=2”，基于栈的指令集是这样的：</p><pre data-anchor-id="i6nz"><code>iconst_1
iconst_1
iadd
istore_0
</code></pre><p data-anchor-id="yzdf">两条iconst_1指令连续地把两个常量1压入栈中，iadd指令把栈顶的两个值出栈相加，把结果放回栈顶，最后istore_0把栈顶的值放到局部变量表的第0个Slot中。</p><div class="md-section-divider"></div><h3 data-anchor-id="84b0" id="什么是基于寄存器的指令集">什么是基于寄存器的指令集？</h3><p data-anchor-id="util">最典型的是x86的地址指令集，依赖寄存器工作。 <br>
        计算“1+1=2”，基于寄存器的指令集是这样的：</p><pre data-anchor-id="woyi"><code>mov eax,  1
add eax,  1
</code></pre><p data-anchor-id="oepi">mov指令把EAX寄存器的值设为1，然后add指令再把这个值加1，结果就保存在EAX寄存器里。</p><div class="md-section-divider"></div><h3 data-anchor-id="uc3o" id="基于栈的指令集的优缺点">基于栈的指令集的优缺点？</h3><p data-anchor-id="oz4t"><strong>优点：</strong></p><ul data-anchor-id="rdgi">
        <li><p><font color="#ff0000">可移植性好</font>：用户程序不会直接用到这些寄存器，由虚拟机自行决定把一些访问最频繁的数据（程序计数器、栈顶缓存）放到寄存器以获取更好的性能。</p></li>
        <li><p><font color="#ff0000">代码相对紧凑</font>：字节码中每个字节就对应一条指令</p></li>
        <li><p><font color="#ff0000">编译器实现简单</font>：不需要考虑空间分配问题，所需空间都在栈上操作</p></li>
    </ul><p data-anchor-id="gcnc"><strong>缺点：</strong></p><ul data-anchor-id="i2b1">
        <li><p>执行速度稍慢</p></li>
        <li><p>完成相同功能所需的指令熟练多</p></li>
    </ul><p data-anchor-id="csw2">频繁的访问栈，意味着频繁的访问内存，相对于处理器，内存才是执行速度的瓶颈。</p><div class="md-section-divider"></div><h1 data-anchor-id="gxys" id="javac编译过程分为哪些步骤">Javac编译过程分为哪些步骤？</h1><ol data-anchor-id="qdxm">
        <li><p>解析与填充符号表</p></li>
        <li><p>插入式注解处理器的注解处理</p></li>
        <li><p>分析与字节码生成</p></li>
    </ol><p data-anchor-id="55en"><img src="http://static.zybuluo.com/Yano/r4pec2h5oqj8i4ddeeurea3h/10.jpg" alt="" title=""></p><div class="md-section-divider"></div><h1 data-anchor-id="sqmb" id="什么是即时编译器">什么是即时编译器？</h1><p data-anchor-id="ooww">Java程序最初是通过解释器进行解释执行的，当虚拟机发现某个方法或代码块的运行特别频繁，就会把这些代码认定为“<font color="#ff0000">热点代码</font>”（Hot Spot Code）。</p><p data-anchor-id="ux66">为了提高热点代码的执行效率，在<font color="#ff0000">运行时</font>，虚拟机将会把这些代码<font color="#ff0000">编译成与本地平台相关的机器码</font>，并进行<font color="#ff0000">各种层次的优化</font>，完成这个任务的编译器成为<font color="#ff0000">即时编译器</font>（Just In Time Compiler，<font color="#ff0000">JIT</font>编译器）。</p><div class="md-section-divider"></div><h1 data-anchor-id="fwt4" id="解释器和编译器">解释器和编译器</h1><p data-anchor-id="02bs">许多主流的商用虚拟机，都同时包含解释器和编译器。</p><ul data-anchor-id="gg9c">
        <li><p>当程序需要<font color="#ff0000">快速启动和执行</font>时，<font color="#ff0000">解释器</font>首先发挥作用，省去编译的时间，立即执行。</p></li>
        <li><p>当程序运行后，随着时间的推移，<font color="#ff0000">编译器</font>逐渐发挥作用，把越来越多的代码编译成本地代码，可以<font color="#ff0000">提高执行效率</font>。</p></li>
    </ul><p data-anchor-id="ets9">如果内存资源限制较大（部分嵌入式系统），可以使用解释执行节约内存，反之可以使用编译执行来提升效率。同时编译器的代码还能退回成解释器的代码。</p><p data-anchor-id="wz1p"><img src="http://static.zybuluo.com/Yano/rm4obt2e7nl1saopktrjkjqm/11.jpg" alt="" title=""></p><div class="md-section-divider"></div><h3 data-anchor-id="1chg" id="为什么要采用分层编译">为什么要采用<font color="#ff0000">分层编译</font>？</h3><p data-anchor-id="39cc">因为即时编译器编译本地代码需要占用程序运行时间，要编译出优化程度更高的代码，所花费的时间越长。</p><div class="md-section-divider"></div><h3 data-anchor-id="exq2" id="分层编译器有哪些层次">分层编译器有哪些层次？</h3><p data-anchor-id="pv9p">分层编译根据编译器编译、优化的规模和耗时，划分不同的编译层次，包括：</p><ul data-anchor-id="3br3">
        <li><p>第0层：程序解释执行，解释器不开启性能监控功能，可出发第1层编译。</p></li>
        <li><p>第1层：也成为C1编译，将字节码编译为本地代码，进行简单可靠的优化，如有必要加入性能监控的逻辑。</p></li>
        <li><p>第2层：也成为C2编译，也是将字节码编译为本地代码，但是会启用一些编译耗时较长的优化，甚至会根据性能监控信息进行一些不可靠的激进优化。</p></li>
    </ul><p data-anchor-id="z9o1">用Client Compiler和Server Compiler将会同时工作。用Client Compiler获取更高的编译速度，用Server Compiler获取更好的编译质量。</p><div class="md-section-divider"></div><h1 data-anchor-id="m6ns" id="编译对象与触发条件">编译对象与触发条件</h1><div class="md-section-divider"></div><h3 data-anchor-id="3x6i" id="热点代码有哪些">热点代码有哪些？</h3><ul data-anchor-id="1hqe">
        <li><p>被多次调用的方法</p></li>
        <li><p>被多次执行的循环体</p></li>
    </ul><div class="md-section-divider"></div><h3 data-anchor-id="1rov" id="如何判断一段代码是不是热点代码">如何判断一段代码是不是热点代码？</h3><p data-anchor-id="hy4f">要知道一段代码是不是热点代码，是不是需要触发即时编译，这个行为称为热点探测。主要有两种方法：</p><ul data-anchor-id="hx8f">
        <li><p><font color="#ff0000">基于采样的热点探测</font>，虚拟机周期性检查各个线程的栈顶，如果发现某个方法经常出现在栈顶，那这个方法就是“热点方法”。实现简单高效，但是很难精确确认一个方法的热度。</p></li>
        <li><p><font color="#ff0000">基于计数器的热点探测</font>，虚拟机会为每个方法建立计数器，统计方法的执行次数，如果执行次数超过一定的阈值，就认为它是热点方法。</p></li>
    </ul><div class="md-section-divider"></div><h3 data-anchor-id="1v7c" id="hotspot虚拟机使用第二种有两个计数器">HotSpot虚拟机使用第二种，有两个计数器：</h3><ul data-anchor-id="mitv">
        <li><p>方法调用计数器</p></li>
        <li><p>回边计数器（判断循环代码）</p></li>
    </ul><div class="md-section-divider"></div><h3 data-anchor-id="viu9" id="方法调用计数器统计方法">方法调用计数器统计方法</h3><p data-anchor-id="ix8o">统计的是一个相对的执行频率，即一段时间内方法被调用的次数。当超过<font color="#ff0000">一定的时间限度</font>，如果方法的调用次数仍然不足以让它提交给即时编译器编译，那这个方法的调用计数器就会被减少一半，这个过程称为方法调用计数器的<font color="#ff0000">热度衰减</font>，这个时间就被称为<font color="#ff0000">半衰周期</font>。</p><div class="md-section-divider"></div><h1 data-anchor-id="s8zj" id="有哪些经典的优化技术即时编译器">有哪些经典的优化技术（即时编译器）？</h1><ul data-anchor-id="rzfo">
        <li><p>语言无关的经典优化技术之一：<font color="#ff0000">公共子表达式消除</font></p></li>
        <li><p>语言相关的经典优化技术之一：<font color="#ff0000">数组范围检查消除</font></p></li>
        <li><p>最重要的优化技术之一：<font color="#ff0000">方法内联</font></p></li>
        <li><p>最前沿的优化技术之一：<font color="#ff0000">逃逸分析</font></p></li>
    </ul><div class="md-section-divider"></div><h3 data-anchor-id="5nqc" id="公共子表达式消除">公共子表达式消除</h3><p data-anchor-id="ddwi">普遍应用于各种编译器的经典优化技术，它的含义是：</p><pre data-anchor-id="6gyo"><code>如果一个表达式E已经被计算过了，并且从先前的计算到现在E中所有变量的值都没有发生变化，那么E的这次出现就成了公共子表达式。没有必要重新计算，直接用结果代替E就可以了。
</code></pre><div class="md-section-divider"></div><h3 data-anchor-id="tss6" id="数组边界检查消除">数组边界检查消除</h3><p data-anchor-id="uesr">因为Java会自动检查数组越界，每次数组元素的读写都带有一次隐含的条件判定操作，对于拥有大量数组访问的程序代码，这无疑是一种性能负担。</p><p data-anchor-id="jmyn">如果数组访问发生在循环之中，并且使用循环变量来进行数组访问，如果编译器只要通过数据流分析就可以判定循环变量的取值范围永远在数组区间内，那么整个循环中就可以把数组的上下界检查消除掉，可以节省很多次的条件判断操作。</p><div class="md-section-divider"></div><h3 data-anchor-id="kyei" id="方法内联">方法内联</h3><p data-anchor-id="yoer">内联消除了方法调用的成本，还为其他优化手段建立良好的基础。</p><p data-anchor-id="wlyg">编译器在进行内联时，如果是非虚方法，那么直接内联。如果遇到虚方法，则会查询当前程序下是否有多个目标版本可供选择，如果查询结果只有一个版本，那么也可以内联，不过这种内联属于<font color="#ff0000">激进优化</font>，需要预留一个<font color="#ff0000">逃生门</font>（Guard条件不成立时的Slow Path），称为<font color="#ff0000">守护内联</font>。</p><p data-anchor-id="7xz6">如果程序的后续执行过程中，虚拟机一直没有加载到会令这个方法的接受者的继承关系发现变化的类，那么内联优化的代码可以一直使用。否则需要抛弃掉已经编译的代码，退回到解释状态执行，或者重新进行编译。</p><div class="md-section-divider"></div><h3 data-anchor-id="lkat" id="逃逸分析">逃逸分析</h3><p data-anchor-id="ap7l">逃逸分析的基本行为就是<font color="#ff0000">分析对象动态作用域</font>：当一个对象在方法里面被定义后，它可能被外部方法所引用，这种行为被称为<font color="#ff0000">方法逃逸</font>。被外部线程访问到，被称为<font color="#ff0000">线程逃逸</font>。</p><div class="md-section-divider"></div><h1 data-anchor-id="m0l8" id="如果对象不会逃逸到方法或线程外可以做什么优化">如果<font color="#ff0000">对象</font>不会逃逸到方法或线程外，可以做什么优化？</h1><ul data-anchor-id="mle5">
        <li><p><font color="#ff0000">栈上分配</font>：一般对象都是分配在Java堆中的，对于各个线程都是共享和可见的，只要持有这个对象的引用，就可以访问堆中存储的对象数据。但是垃圾回收和整理都会耗时，如果一个对象不会逃逸出方法，可以让这个对象在栈上分配内存，对象所占用的内存空间就可以随着栈帧出栈而销毁。如果能使用栈上分配，那大量的对象会随着方法的结束而自动销毁，垃圾回收的压力会小很多。</p></li>
        <li><p><font color="#ff0000">同步消除</font>：线程同步本身就是很耗时的过程。如果逃逸分析能确定一个变量不会逃逸出线程，那这个变量的读写肯定就不会有竞争，同步措施就可以消除掉。</p></li>
        <li><p><font color="#ff0000">标量替换</font>：不创建这个对象，直接创建它的若干个被这个方法使用到的成员变量来替换。</p></li>
    </ul><div class="md-section-divider"></div><h1 data-anchor-id="rfb0" id="java与cc的编译器对比">Java与C/C++的编译器对比</h1><ol data-anchor-id="ga4z">
        <li>即时编译器运行占用的是用户程序的运行时间，具有很大的时间压力。</li>
        <li>Java语言虽然没有virtual关键字，但是使用虚方法的频率远大于C++，所以即时编译器进行优化时难度要远远大于C++的静态优化编译器。</li>
        <li>Java语言是可以动态扩展的语言，运行时加载新的类可能改变程序类型的继承关系，使得全局的优化难以进行，因为编译器无法看见程序的全貌，编译器不得不时刻注意并随着类型的变化，而在运行时撤销或重新进行一些优化。</li>
        <li>Java语言对象的内存分配是在堆上，只有方法的局部变量才能在栈上分配。C++的对象有多种内存分配方式。</li>
    </ol><div class="md-section-divider"></div><h1 data-anchor-id="sbly" id="物理机如何处理并发问题">物理机如何处理并发问题？</h1><p data-anchor-id="umxs">运算任务，除了需要<font color="#ff0000">处理器计算</font>之外，还需要与<font color="#ff0000">内存交互</font>，如读取运算数据、存储运算结果等（不能仅靠寄存器来解决）。 <br>
        计算机的存储设备和处理器的运算速度差了几个数量级，所以不得不加入一层读写速度尽可能接近处理器运算速度的<font color="#ff0000">高速缓存</font>（Cache），作为内存与处理器之间的缓冲：将运算需要的数据复制到缓存中，让运算快速运行。当运算结束后再从缓存同步回内存，这样处理器就无需等待缓慢的内存读写了。 <br>
        基于高速缓存的存储交互很好地解决了处理器与内存的速度矛盾，但是引入了一个新的问题：<font color="#ff0000">缓存一致性</font>。在多处理器系统中，每个处理器都有自己的高速缓存，它们又共享同一主内存。当多个处理器的运算任务都涉及同一块主内存时，可能导致各自的缓存数据不一致。 <br>
        为了解决一致性的问题，需要各个处理器访问缓存时遵循缓存一致性协议。同时为了使得处理器充分被利用，处理器可能会对输出代码进行<font color="#ff0000">乱序执行优化</font>。Java虚拟机的即时编译器也有类似的<font color="#ff0000">指令重排序优化</font>。 <br>
    </p><div class="md-section-divider"></div><h1 data-anchor-id="clkg" id="java-内存模型">Java 内存模型</h1><div class="md-section-divider"></div><h2 data-anchor-id="usxy" id="什么是java内存模型">什么是Java内存模型？</h2><p data-anchor-id="j39m">Java虚拟机的规范，用来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各个平台下都能达到一致的并发效果。</p><div class="md-section-divider"></div><h2 data-anchor-id="c8ge" id="java内存模型的目标">Java内存模型的目标？</h2><p data-anchor-id="h3fw">定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中取出这样的底层细节。此处的变量包括实例字段、静态字段和构成数组对象的元素，但是不包括局部变量和方法参数，因为这些是线程私有的，不会被共享，所以不存在竞争问题。</p><div class="md-section-divider"></div><h3 data-anchor-id="geg0" id="主内存与工作内存">主内存与工作内存</h3><p data-anchor-id="hrys">所以的变量都存储在主内存，每条线程还有自己的工作内存，保存了被该线程使用到的变量的主内存副本拷贝。线程对变量的所有操作（读取、赋值）都必须在工作内存中进行，不能直接读写主内存的变量。不同的线程之间也无法直接访问对方工作内存的变量，线程间变量值的传递需要通过主内存。</p><p data-anchor-id="a9bu"><img src="http://static.zybuluo.com/Yano/k7gxbb68208ywkpa6uzi342b/12.jpg" alt="" title=""></p><div class="md-section-divider"></div><h3 data-anchor-id="n8cm" id="内存间的交互操作">内存间的交互操作</h3><p data-anchor-id="4b9r">一个变量如何从主内存拷贝到工作内存、如何从工作内存同步回主内存，Java内存模型定义了8种操作：</p><p data-anchor-id="2xh9"><img src="http://static.zybuluo.com/Yano/eawdhrehz9w4ikwsnsxprbbu/13.png" alt="" title=""></p><div class="md-section-divider"></div><h3 data-anchor-id="2wa9" id="原子性可见性有序性">原子性、可见性、有序性</h3><ul data-anchor-id="vdt5">
        <li><p><font color="#ff0000">原子性</font>：对<font color="#ff0000">基本数据类型</font>的访问和读写是<font color="#ff0000">具备原子性</font>的。对于<font color="#ff0000">更大范围的原子性保证</font>，可以使用字节码指令monitorenter和monitorexit来隐式使用lock和unlock操作。这两个字节码指令反映到Java代码中就是<font color="#ff0000">同步块</font>——<font color="#ff0000">synchronized</font>关键字。因此synchronized块之间的操作也具有原子性。</p></li>
        <li><p><font color="#ff0000">可见性</font>：当一个线程修改了共享变量的值，其他线程能够<font color="#ff0000">立即得知这个修改</font>。Java内存模型是通过在变量修改后将新值同步回主内存，在变量读取之前从主内存刷新变量值来实现可见性的。volatile的特殊规则保证了新值能够立即同步到主内存，每次使用前立即从主内存刷新。<font color="#ff0000">synchronized</font>和<font color="#ff0000">final</font>也能实现可见性。final修饰的字段在构造器中一旦被初始化完成，并且构造器没有把this的引用传递出去，那么其他线程中就能看见final字段的值。</p></li>
        <li><p><font color="#ff0000">有序性</font>：Java程序的有序性可以总结为一句话，如果在本线程内观察，所有的操作都是有序的（线程内表现为串行的语义）；如果在一个线程中观察另一个线程，所有的操作都是无序的（指令重排序和工作内存与主内存同步延迟线性）。</p></li>
    </ul><div class="md-section-divider"></div><h1 data-anchor-id="f8zv" id="volatile">volatile</h1><div class="md-section-divider"></div><h3 data-anchor-id="m9fz" id="什么是volatile">什么是volatile？</h3><p data-anchor-id="64cq">关键字volatile是Java虚拟机提供的最<font color="#ff0000">轻量级的同步机制</font>。当一个变量被定义成volatile之后，具备两种特性：</p><ol data-anchor-id="db91">
        <li><p><font color="#ff0000">保证此变量对所有线程的可见性</font>。当一条线程修改了这个变量的值，新值对于其他线程是可以立即得知的。而普通变量做不到这一点。</p></li>
        <li><p><font color="#ff0000">禁止指令重排序优化</font>。普通变量仅仅能保证在该方法执行过程中，得到正确结果，但是不保证程序代码的执行顺序。</p></li>
    </ol><div class="md-section-divider"></div><h3 data-anchor-id="5jxe" id="为什么基于volatile变量的运算在并发下不一定是安全的">为什么基于volatile变量的运算在并发下不一定是安全的？</h3><p data-anchor-id="88w5">volatile变量在各个线程的工作内存，不存在一致性问题（各个线程的工作内存中volatile变量，每次使用前都要刷新到主内存）。但是Java里面的运算并非原子操作，导致volatile变量的运算在并发下一样是不安全的。</p><div class="md-section-divider"></div><h3 data-anchor-id="x6uh" id="为什么使用volatile">为什么使用volatile？</h3><p data-anchor-id="yc2n">在某些情况下，volatile同步机制的性能要优于锁（synchronized关键字），但是由于虚拟机对锁实行的许多消除和优化，所以并不是很快。</p><p data-anchor-id="gsfq">volatile变量读操作的性能消耗与普通变量几乎没有差别，但是<font color="#ff0000">写操作则可能慢</font>一些，因为它需要在本地代码中插入许多<font color="#ff0000">内存屏障指令</font>来保证处理器<font color="#ff0000">不发生乱序执行</font>。</p><div class="md-section-divider"></div><h1 data-anchor-id="emmv" id="并发与线程">并发与线程</h1><div class="md-section-divider"></div><h3 data-anchor-id="nqgh" id="并发与线程的关系">并发与线程的关系？</h3><p data-anchor-id="yna4">并发不一定要依赖多线程，PHP中有多进程并发。但是Java里面的并发是多线程的。</p><div class="md-section-divider"></div><h3 data-anchor-id="mnjq" id="什么是线程">什么是线程？</h3><p data-anchor-id="ujra">线程是比进程更轻量级的调度执行单位。线程可以把一个进程的<font color="#ff0000">资源分配</font>和<font color="#ff0000">执行调度</font>分开，各个线程既可以<font color="#ff0000">共享进程资源</font>（内存地址、文件I/O），又可以<font color="#ff0000">独立调度</font>（线程是CPU调度的最基本单位）。</p><div class="md-section-divider"></div><h3 data-anchor-id="495q" id="实现线程有哪些方式">实现线程有哪些方式？</h3><ul data-anchor-id="i4lx">
        <li><p>使用内核线程实现</p></li>
        <li><p>使用用户线程实现</p></li>
        <li><p>使用用户线程+轻量级进程混合实现</p></li>
    </ul><div class="md-section-divider"></div><h3 data-anchor-id="hi81" id="java线程的实现">Java线程的实现</h3><p data-anchor-id="vyod">操作系统支持怎样的线程模型，在很大程度上就决定了Java虚拟机的线程是怎样映射的。</p><div class="md-section-divider"></div><h1 data-anchor-id="tty8" id="java线程调度">Java线程调度</h1><div class="md-section-divider"></div><h3 data-anchor-id="lr0c" id="什么是线程调度">什么是线程调度？</h3><p data-anchor-id="ki26">线程调度是系统为<font color="#ff0000">线程分配处理器使用权</font>的过程。</p><div class="md-section-divider"></div><h3 data-anchor-id="xljw" id="线程调度有哪些方法">线程调度有哪些方法？</h3><ul data-anchor-id="nr12">
        <li><p>协同式线程调度：实现简单，没有线程同步的问题。但是线程执行时间不可控，容易系统崩溃。</p></li>
        <li><p>抢占式线程调度：每个线程由系统来分配执行时间，不会有线程导致整个进程阻塞的问题。</p></li>
    </ul><p data-anchor-id="oqze">虽然Java线程调度是系统自动完成的，但是我们可以建议系统给某些线程多分配点时间——设置<font color="#ff0000">线程优先级</font>。Java语言有<font color="#ff0000">10个级别</font>的线程优先级，优先级越高的线程，越容易被系统选择执行。</p><p data-anchor-id="p4pn">但是并不能完全依靠线程优先级。因为Java的线程是被映射到系统的原生线程上，所以线程调度最终还是由操作系统说了算。如Windows中只有7种优先级，所以Java不得不出现几个优先级相同的情况。同时优先级可能会被系统自行改变。Windows系统中存在一个“<font color="#ff0000">优先级推进器</font>”，当系统发现一个线程执行特别勤奋，可能会越过线程优先级为它分配执行时间。</p><div class="md-section-divider"></div><h1 data-anchor-id="1ykw" id="线程安全的定义">线程安全的定义？</h1><p data-anchor-id="6xux">当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方法进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的。</p><div class="md-section-divider"></div><h1 data-anchor-id="qqhh" id="java语言操作的共享数据包括哪些">Java语言操作的共享数据，包括哪些？</h1><ul data-anchor-id="z76k">
        <li><p>不可变</p></li>
        <li><p>绝对线程安全</p></li>
        <li><p>相对线程安全</p></li>
        <li><p>线程兼容</p></li>
        <li><p>线程对立</p></li>
    </ul><div class="md-section-divider"></div><h3 data-anchor-id="lzvb" id="不可变">不可变</h3><p data-anchor-id="631x">在Java语言里，不可变的对象一定是线程安全的，只要一个不可变的对象被正确构建出来，那其外部的可见状态永远也不会改变，永远也不会在多个线程中处于不一致的状态。</p><div class="md-section-divider"></div><h1 data-anchor-id="o4ar" id="如何实现线程安全">如何实现线程安全？</h1><p data-anchor-id="yzs3">虚拟机提供了<font color="#ff0000">同步</font>和<font color="#ff0000">锁</font>机制。</p><ul data-anchor-id="vlan">
        <li><p>阻塞同步（互斥同步）</p></li>
        <li><p>非阻塞同步</p></li>
    </ul><div class="md-section-divider"></div><h3 data-anchor-id="7tlw" id="阻塞同步互斥同步">阻塞同步（互斥同步）</h3><p data-anchor-id="ohxt"><font color="#ff0000">互斥</font>是实现同步的一种手段，<font color="#ff0000">临界区</font>、<font color="#ff0000">互斥量</font>和<font color="#ff0000">信号量</font>都是主要的互斥实现方式。Java中最基本的同步手段就是<font color="#ff0000">synchronized</font>关键字，其编译后会在同步块的前后分别形成<font color="#ff0000">monitorenter</font>和<font color="#ff0000">monitorexit</font>两个字节码指令。这两个字节码都需要一个Reference类型的参数指明要锁定和解锁的对象。如果Java程序中的synchronized明确指定了对象参数，那么这个对象就是Reference；如果没有明确指定，那就根据synchronized修饰的是实例方法还是类方法，去获取对应的对象实例或Class对象作为锁对象。 <br>
        在执行monitorenter指令时，首先要尝试获取对象的锁。</p><ul data-anchor-id="dsfe">
        <li><p>如果这个对象没有锁定，或者当前线程已经拥有了这个对象的锁，把锁的计数器+1；当执行monitorexit指令时将锁计数器-1。当计数器为0时，锁就被释放了。</p></li>
        <li><p>如果获取对象失败了，那当前线程就要阻塞等待，知道对象锁被另外一个线程释放为止。</p></li>
    </ul><p data-anchor-id="qz5z">除了synchronized之外，还可以使用java.util.concurrent包中的<font color="#ff0000">重入锁</font>（<font color="#ff0000">ReentrantLock</font>）来实现同步。ReentrantLock比synchronized增加了高级功能：等待可中断、可实现公平锁、锁可以绑定多个条件。</p><p data-anchor-id="kt2e">等待可中断：当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，对处理执行时间非常长的同步块很有用。</p><p data-anchor-id="zj2n"><font color="#ff0000">公平锁</font>：多个线程在等待同一个锁时，必须<font color="#ff0000">按照申请锁的时间顺序</font>来依次获得锁。<font color="#ff0000">synchronized</font>中的锁是<font color="#ff0000">非公平</font>的。</p><div class="md-section-divider"></div><h3 data-anchor-id="wwml" id="非阻塞同步">非阻塞同步</h3><p data-anchor-id="oo7s"><font color="#ff0000">互斥同步</font>最大的问题，就是进行<font color="#ff0000">线程阻塞和唤醒所带来的性能问题</font>，是一种<font color="#ff0000">悲观的并发策略</font>。总是认为只要不去做正确的同步措施（加锁），那就肯定会出问题，无论共享数据是否真的会出现竞争，它都要进行加锁、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要被唤醒等操作。</p><p data-anchor-id="j6qd">随着硬件指令集的发展，我们可以使用<font color="#ff0000">基于冲突检测的乐观并发策略</font>。<font color="#ff0000">先进行操作</font>，如果没有其他线程征用数据，那操作就成功了；如果共享数据有征用，产生了冲突，那就再进行其他的补偿措施。这种乐观的并发策略的许多实现<font color="#ff0000">不需要线程挂起</font>，所以被称为<font color="#ff0000">非阻塞同步</font>。</p><div class="md-section-divider"></div><h1 data-anchor-id="5zek" id="锁优化是在jdk的那个版本">锁优化是在JDK的那个版本？</h1><p data-anchor-id="b4w4">JDK1.6的一个重要主题，就是<font color="#ff0000">高效并发</font>。HotSpot虚拟机开发团队在这个版本上，实现了各种锁优化：</p><ul data-anchor-id="wuvf">
        <li><p>适应性自旋</p></li>
        <li><p>锁消除</p></li>
        <li><p>锁粗化</p></li>
        <li><p>轻量级锁</p></li>
        <li><p>偏向锁</p></li>
    </ul><div class="md-section-divider"></div><h3 data-anchor-id="j9ny" id="为什么要提出自旋锁">为什么要提出自旋锁？</h3><p data-anchor-id="vjss">互斥同步对性能最大的影响是阻塞的实现，<font color="#ff0000">挂起线程</font>和<font color="#ff0000">恢复线程</font>的操作都需要<font color="#ff0000">转入内核态</font>中完成，这些操作给系统的并发性带来很大压力。同时很多应用共享数据的锁定状态，只会<font color="#ff0000">持续很短的一段时间</font>，为了这段时间去挂起和恢复线程并不值得。先不挂起线程，等一会儿。</p><div class="md-section-divider"></div><h3 data-anchor-id="znt0" id="自旋锁的原理">自旋锁的原理？</h3><p data-anchor-id="outy">如果物理机器有一个以上的处理器，能让两个或以上的线程同时并行执行，让后面请求锁的线程稍等一会，但不放弃处理器的执行时间，看看持有锁的线程是否很快就会释放。为了让线程等待，我们只需让线程执行一个忙循环（自旋）。</p><div class="md-section-divider"></div><h3 data-anchor-id="6ny5" id="自旋的缺点">自旋的缺点？</h3><p data-anchor-id="9xvd">自旋等待本身虽然避免了线程切换的开销，但它要占用处理器时间。所以如果锁被占用的时间很短，自旋等待的效果就非常好；如果时间很长，那么自旋的线程只会白白消耗处理器的资源。所以自旋等待的时间要有一定的限度，如果自旋超过了限定的次数仍然没有成功获得锁，那就应该使用传统的方式挂起线程了。</p><div class="md-section-divider"></div><h3 data-anchor-id="lnlr" id="什么是自适应自旋">什么是自适应自旋？</h3><p data-anchor-id="i0v8"><font color="#ff0000">自旋的时间不固定</font>了，而是由<font color="#ff0000">前一次在同一个锁上的自旋时间</font>及<font color="#ff0000">锁的拥有者的状态</font>来决定。</p><ul data-anchor-id="1q1l">
        <li><p>如果一个锁对象，自旋等待刚刚成功获得锁，并且持有锁的线程正在运行，那么虚拟机认为这次自旋仍然可能成功，进而运行自旋等待更长的时间。</p></li>
        <li><p>如果对于某个锁，自旋很少成功，那在以后要获取这个锁，可能省略掉自旋过程，以免浪费处理器资源。</p></li>
    </ul><p data-anchor-id="s54r">有了自适应自旋，随着程序运行和性能监控信息的不断完善，虚拟机对程序锁的状况预测就会越来越准确，虚拟机也会越来越聪明。</p><div class="md-section-divider"></div><h3 data-anchor-id="d3r0" id="锁消除">锁消除</h3><p data-anchor-id="573z">锁消除是指虚拟机即时编译器在运行时，对一些代码上要求同步，但被检测到不可能存在共享数据竞争的锁进行消除。主要根据<font color="#ff0000">逃逸分析</font>。</p><p data-anchor-id="xpn7">程序员怎么会在明知道不存在数据竞争的情况下使用同步呢？很多不是程序员自己加入的。</p><div class="md-section-divider"></div><h3 data-anchor-id="zu4z" id="锁粗化">锁粗化</h3><p data-anchor-id="7x08">原则上，同步块的作用范围要尽量小。但是如果一系列的连续操作都对同一个对象反复加锁和解锁，甚至加锁操作在循环体内，频繁地进行互斥同步操作也会导致不必要的性能损耗。</p><p data-anchor-id="0dc7">锁粗化就是<font color="#ff0000">增大锁的作用域</font>。</p><div class="md-section-divider"></div><h3 data-anchor-id="xs5o" id="轻量级锁">轻量级锁</h3><p data-anchor-id="s1do">在没有多线程竞争的前提下，减少传统的重量级锁使用操作系统互斥量产生的性能消耗。</p><div class="md-section-divider"></div><h3 data-anchor-id="4v2z" id="偏向锁">偏向锁</h3><p data-anchor-id="plx4">消除数据在无竞争情况下的同步原语，进一步提高程序的运行性能。即在无竞争的情况下，<font color="#ff0000">把整个同步都消除掉</font>。这个锁会偏向于第一个获得它的线程，如果在接下来的执行过程中，该锁没有被其他的线程获取，则持有偏向锁的线程将永远不需要同步。</p></div>
    <div class="remark-icons">
    </div>
</div>

<!--in page preview buttons. -->
<div class="in-page-preview-buttons in-page-preview-buttons-full-reader">
    <ul  id="preview-toc-button" title="内容目录 Ctrl+Alt+O">
        <span class="dropdown-toggle icon-list" data-toggle="dropdown"></span>
        <div id="toc-list" class="dropdown-menu theme pull-right"> <!-- Add theme means this element will be changed when apply theme color. -->
            <hr>
        </div>
    </ul>
</div>




</body>
</html>